" TODO print messages when on visual mode. I only see VISUAL, not the messages.

" Function interface phylosophy:
    "
    " - functions take arbitrary line numbers as parameters.
    "    Current cursor line is only a suitable default parameter.
    "
    " - only functions that bind directly to user actions will:
    "
    "    - print error messages.
    "       All intermediate functions limit themselves return `0` to indicate an error.
    "
    "    - move the cursor.
    "        All other functions do not move the cursor.
    "
    " This is how you should view headers for the header mappings:
    "
    "   |BUFFER
    "   |
    "   |Outside any header
    "   |
    " a-+# a
    "   |
    "   |Inside a
    "   |
    " a-+
    " b-+## b
    "   |
    "   |inside b
    "   |
    " b-+
    " c-+### c
    "   |
    "   |Inside c
    "   |
    " c-+
    " d-|# d
    "   |
    "   |Inside d
    "   |
    " d-+
    " e-|e
    "   |====
    "   |
    "   |Inside e
    "   |
    " e-+

" For each level, contains the regexp that matches at that level only.
    let s:levelRegexpDict = {
        \ 1: '\v^(#[^#]@=|.+\n\=+$)',
        \ 2: '\v^(##[^#]@=|.+\n-+$)',
        \ 3: '\v^###[^#]@=',
        \ 4: '\v^####[^#]@=',
        \ 5: '\v^#####[^#]@=',
        \ 6: '\v^######[^#]@='
    \ }

" Maches any header level of any type.
let s:headersRegexp = '\v^(#|.+\n(\=+|-+)$)'
    " This could be deduced from `s:levelRegexpDict`, but it is more
    " efficient to have a single regexp for this.

"
fun! s:GetHeaderLineNum(...)
    " Returns the line number of the first header before `line`,
    " called the  current header.
    "
    " @param a:1 The line to look the header of.
    " Default value: `getpos('.')`.
    if a:0 == 0
        let l:l = line('.')
    el
        let l:l = a:1
    en

    while(l:l > 0)
        if join(getline(l:l, l:l + 1), "\n") =~ s:headersRegexp
            return l:l
        en
        let l:l -= 1
    endwhile
    return 0
    " If there is no current header, return `0`.
endf


fun! s:MoveToCurHeader()
    " -  if inside a header goes to it.
    "    Return its line number.
    "
    " -  if on top level outside any headers,
    "    print a warning
    "    Return `0`.

    let l:lineNum = s:GetHeaderLineNum()
    if l:lineNum !=# 0
        call cursor(l:lineNum, 1)
    el
        echo 'outside any header'
        "normal! gg
    en
    return l:lineNum
endf

"
fun! s:MoveToNextHeader()
    " Move cursor to next header of any level.
    " If there are no more headers, print a warning.
    if search(s:headersRegexp, 'W') == 0
        "normal! G
        echo 'no next header'
    en
endf

"
fun! s:MoveToPreviousHeader()
    " Move cursor to previous header (before current) of any level.
    " If it does not exist, print a warning.
    let l:curHeaderLineNumber = s:GetHeaderLineNum()
    let l:noPreviousHeader = 0
    if l:curHeaderLineNumber <= 1
        let l:noPreviousHeader = 1
    el
        let l:previousHeaderLineNumber = s:GetHeaderLineNum(l:curHeaderLineNumber - 1)
        if l:previousHeaderLineNumber == 0
            let l:noPreviousHeader = 1
        el
            call cursor(l:previousHeaderLineNumber, 1)
        en
    en
    if l:noPreviousHeader
        echo 'no previous header'
    en
endf

" - if line is inside a header, return the header level (h1 -> 1, h2 -> 2, etc.).
"
" - if line is at top level outside any headers, return `0`.
"
fun! s:GetHeaderLevel(...)
    if a:0 == 0
        let l:line = line('.')
    el
        let l:line = a:1
    en
    let l:linenum = s:GetHeaderLineNum(l:line)
    if l:linenum !=# 0
        return s:GetLevelOfHeaderAtLine(l:linenum)
    el
        return 0
    en
endf

" Return list of headers and their levels.
"
fun! s:GetHeaderList()
    let l:bufnr = bufnr('%')
    let l:fenced_block = 0
    let l:front_matter = 0
    let l:header_list = []
    let l:vim_markdown_frontmatter = get(g:, 'vim_markdown_frontmatter', 0)
    for i in range(1, line('$'))
        let l:lineraw = getline(i)
        let l:l1 = getline(i+1)
        let l:line = substitute(l:lineraw, '#', "\\\#", 'g')
        " exclude lines in fenced code blocks
        if l:line =~# '````*' || l:line =~# '\~\~\~\~*'
            if l:fenced_block == 0
                let l:fenced_block = 1
            elseif l:fenced_block == 1
                let l:fenced_block = 0
            en
        " exclude lines in frontmatters
        elseif l:vim_markdown_frontmatter == 1
            if l:front_matter == 1
                if l:line ==# '---'
                    let l:front_matter = 0
                en
            elseif i == 1
                if l:line ==# '---'
                    let l:front_matter = 1
                en
            en
        en
        " match line against header regex
        if join(getline(i, i + 1), "\n") =~# s:headersRegexp && l:line =~# '^\S'
            let l:is_header = 1
        el
            let l:is_header = 0
        en
        if l:is_header ==# 1 && l:fenced_block ==# 0 && l:front_matter ==# 0
            " remove hashes from atx headers
            if match(l:line, '^#') > -1
                let l:line = substitute(l:line, '\v^#*[ ]*', '', '')
                let l:line = substitute(l:line, '\v[ ]*#*$', '', '')
            en
            " append line to list
            let l:level = s:GetHeaderLevel(i)
            let l:item = {'level': l:level, 'text': l:line, 'lnum': i, 'bufnr': bufnr}
            let l:header_list = l:header_list + [l:item]
        en
    endfor
    return l:header_list
endf

" Returns the level of the header at the given line.
"
" If there is no header at the given line, returns `0`.
"
fun! s:GetLevelOfHeaderAtLine(linenum)
    let l:lines = join(getline(a:linenum, a:linenum + 1), "\n")
    for l:key in keys(s:levelRegexpDict)
        if l:lines =~ get(s:levelRegexpDict, l:key)
            return l:key
        en
    endfor
    return 0
endf

" Move cursor to parent header of the current header.
"
" If it does not exit, print a warning and do nothing.
"
fun! s:MoveToParentHeader()
    let l:linenum = s:GetParentHeaderLineNumber()
    if l:linenum != 0
        call setpos("''", getpos('.'))
        call cursor(l:linenum, 1)
    el
        echo 'no parent header'
    en
endf

" Return the line number of the parent header of line `line`.
"
" If it has no parent, return `0`.
"
fun! s:GetParentHeaderLineNumber(...)
    if a:0 == 0
        let l:line = line('.')
    el
        let l:line = a:1
    en
    let l:level = s:GetHeaderLevel(l:line)
    if l:level > 1
        let l:linenum = s:GetPreviousHeaderLineNumberAtLevel(l:level - 1, l:line)
        return l:linenum
    en
    return 0
endf

" Return the line number of the previous header of given level.
" in relation to line `a:1`. If not given, `a:1 = getline()`
"
" `a:1` line is included, and this may return the current header.
"
" If none return 0.
"
fun! s:GetNextHeaderLineNumberAtLevel(level, ...)
    if a:0 < 1
        let l:line = line('.')
    el
        let l:line = a:1
    en
    let l:l = l:line
    while(l:l <= line('$'))
        if join(getline(l:l, l:l + 1), "\n") =~ get(s:levelRegexpDict, a:level)
            return l:l
        en
        let l:l += 1
    endwhile
    return 0
endf

" Return the line number of the previous header of given level.
" in relation to line `a:1`. If not given, `a:1 = getline()`
"
" `a:1` line is included, and this may return the current header.
"
" If none return 0.
"
fun! s:GetPreviousHeaderLineNumberAtLevel(level, ...)
    if a:0 == 0
        let l:line = line('.')
    el
        let l:line = a:1
    en
    let l:l = l:line
    while(l:l > 0)
        if join(getline(l:l, l:l + 1), "\n") =~ get(s:levelRegexpDict, a:level)
            return l:l
        en
        let l:l -= 1
    endwhile
    return 0
endf

" Move cursor to next sibling header.
"
" If there is no next siblings, print a warning and don't move.
"
fun! s:MoveToNextSiblingHeader()
    let l:curHeaderLineNumber = s:GetHeaderLineNum()
    let l:curHeaderLevel = s:GetLevelOfHeaderAtLine(l:curHeaderLineNumber)
    let l:curHeaderParentLineNumber = s:GetParentHeaderLineNumber()
    let l:nextHeaderSameLevelLineNumber = s:GetNextHeaderLineNumberAtLevel(l:curHeaderLevel, l:curHeaderLineNumber + 1)
    let l:noNextSibling = 0
    if l:nextHeaderSameLevelLineNumber == 0
        let l:noNextSibling = 1
    el
        let l:nextHeaderSameLevelParentLineNumber = s:GetParentHeaderLineNumber(l:nextHeaderSameLevelLineNumber)
        if l:curHeaderParentLineNumber == l:nextHeaderSameLevelParentLineNumber
            call cursor(l:nextHeaderSameLevelLineNumber, 1)
        el
            let l:noNextSibling = 1
        en
    en
    if l:noNextSibling
        echo 'no next sibling header'
    en
endf

" Move cursor to previous sibling header.
"
" If there is no previous siblings, print a warning and do nothing.
"
fun! s:MoveToPreviousSiblingHeader()
    let l:curHeaderLineNumber = s:GetHeaderLineNum()
    let l:curHeaderLevel = s:GetLevelOfHeaderAtLine(l:curHeaderLineNumber)
    let l:curHeaderParentLineNumber = s:GetParentHeaderLineNumber()
    let l:previousHeaderSameLevelLineNumber = s:GetPreviousHeaderLineNumberAtLevel(l:curHeaderLevel, l:curHeaderLineNumber - 1)
    let l:noPreviousSibling = 0
    if l:previousHeaderSameLevelLineNumber == 0
        let l:noPreviousSibling = 1
    el
        let l:previousHeaderSameLevelParentLineNumber = s:GetParentHeaderLineNumber(l:previousHeaderSameLevelLineNumber)
        if l:curHeaderParentLineNumber == l:previousHeaderSameLevelParentLineNumber
            call cursor(l:previousHeaderSameLevelLineNumber, 1)
        el
            let l:noPreviousSibling = 1
        en
    en
    if l:noPreviousSibling
        echo 'no previous sibling header'
    en
endf

fun! s:Toc()
    let l:cursor_line          = line('.')
    let l:cursor_header        = 0
    let l:header_list          = s:GetHeaderList()
    let l:indented_header_list = []

    if len(l:header_list) == 0
        echom 'Toc: No headers.'
        return
    en

    let l:header_max_len = 0
    let l:vim_markdown_toc_autofit = get(g:, 'vim_markdown_toc_autofit', 0)
    for head in l:header_list
        " set header number of the cursor position
        if l:cursor_header == 0
            let l:header_line = head.lnum
            if l:header_line == l:cursor_line
                let l:cursor_header = index(l:header_list, head) + 1
            elseif l:header_line > l:cursor_line
                let l:cursor_header = index(l:header_list, head)
            en
        en
        " indent header based on level
        let l:text = repeat('    ',  head.level - 1 ) . head.text

        " keep track of the longest header size (heading level + title)
        let l:total_len = strdisplaywidth(l:text)
        if l:total_len > l:header_max_len
            let l:header_max_len = l:total_len
        en
        " append indented line to list
        let l:item = {'lnum': head.lnum, 'text': l:text, 'valid': 1, 'bufnr': head.bufnr, 'col': 1}
        let l:indented_header_list = l:indented_header_list + [l:item]
    endfor
    call setloclist(0, l:indented_header_list)

    vertical lopen
    " auto-fit toc window when possible to shrink it
    " 我注释掉:
        if (&columns / 2) > l:header_max_len &&
          \ l:vim_markdown_toc_autofit == 1
            " header_max_len + 1 space   for first header
            exe 'vertical resize ' . (l:header_max_len + 1)
        el
            "\ 半屏
            exe 'vertical resize ' . (&columns/2)
        en

    setl     modifiable
    for i in range(1, line('$'))
        " this is the location-list data for the current item
        let d = getloclist(0)[i-1]
        call setline(i, d.text)
    endfor
    setl  nomodified
    setl  nomodifiable
    setl  nowrap
    exe 'normal! ' . l:cursor_header . 'G'
endf

fun! s:InsertToc(format, ...)
    if a:0 > 0
        if type(a:1) != type(0)
            echohl WarningMsg
            echomsg '[vim-markdown] Invalid argument, must be an integer >= 2.'
            echohl None
            return
        en
        let l:max_level = a:1
        if l:max_level < 2
            echohl WarningMsg
            echomsg '[vim-markdown] Maximum level cannot be smaller than 2.'
            echohl None
            return
        en
    el
        let l:max_level = 0
    en

    let l:toc = []
    let l:header_list = s:GetHeaderList()
    if len(l:header_list) == 0
        echom 'InsertToc: No headers.'
        return
    en

    if a:format ==# 'numbers'
        let l:h2_count = 0
        for header in l:header_list
            if header.level == 2
                let l:h2_count += 1
            en
        endfor
        let l:max_h2_number_len = strlen(string(l:h2_count))
    el
        let l:max_h2_number_len = 0
    en

    let l:h2_count = 0
    for header in l:header_list
        let l:level = header.level
        if l:level == 1
            " skip level-1 headers
            continue
        elseif l:max_level != 0 && l:level > l:max_level
            " skip unwanted levels
            continue
        elseif l:level == 2
            " list of level-2 headers can be bullets or numbers
            if a:format ==# 'bullets'
                let l:indent = ''
                let l:marker = '* '
            el
                let l:h2_count += 1
                let l:number_len = strlen(string(l:h2_count))
                let l:indent = repeat(' ', l:max_h2_number_len - l:number_len)
                let l:marker = l:h2_count . '. '
            en
        el
            let l:indent = repeat(' ', l:max_h2_number_len + 2 * (l:level - 2))
            let l:marker = '* '
        en
        let l:text = '[' . header.text . ']'
        let l:link = '(#' . substitute(tolower(header.text), '\v[ ]+', '-', 'g') . ')'
        let l:line = l:indent . l:marker . l:text . l:link
        let l:toc = l:toc + [l:line]
    endfor

    call append(line('.'), l:toc)
endf

" Convert Setex headers in range `line1 .. line2` to Atx.
"
" Return the number of conversions.
"
fun! s:SetexToAtx(line1, line2)
    let l:originalNumLines = line('$')
    exe 'silent! ' . a:line1 . ',' . a:line2 . 'substitute/\v(.*\S.*)\n\=+$/# \1/'
    exe 'silent! ' . a:line1 . ',' . a:line2 . 'substitute/\v(.*\S.*)\n-+$/## \1/'
    return l:originalNumLines - line('$')
endf

" If `a:1` is 0, decrease the level of all headers in range `line1 .. line2`.
"
" Otherwise, increase the level. `a:1` defaults to `0`.
"
fun! s:HeaderDecrease(line1, line2, ...)
    if a:0 > 0
        let l:increase = a:1
    el
        let l:increase = 0
    en
    if l:increase
        let l:forbiddenLevel = 6
        let l:replaceLevels = [5, 1]
        let l:levelDelta = 1
    el
        let l:forbiddenLevel = 1
        let l:replaceLevels = [2, 6]
        let l:levelDelta = -1
    en
    for l:line in range(a:line1, a:line2)
        if join(getline(l:line, l:line + 1), "\n") =~ s:levelRegexpDict[l:forbiddenLevel]
            echomsg 'There is an h' . l:forbiddenLevel . ' at line ' . l:line . '. Aborting.'
            return
        en
    endfor
    let l:numSubstitutions = s:SetexToAtx(a:line1, a:line2)
    let l:flags = (&gdefault ? '' : 'g')
    for l:level in range(replaceLevels[0], replaceLevels[1], -l:levelDelta)
        exe 'silent! ' . a:line1 . ',' . (a:line2 - l:numSubstitutions) . 'substitute/' . s:levelRegexpDict[l:level] . '/' . repeat('#', l:level + l:levelDelta) . '/' . l:flags
    endfor
endf

"
fun! s:TableFormat()
    " Format table under cursor.
    " Depends on Tabularize.
    let l:pos = getpos('.')
    norm! {
    " Search instead of `normal! j` because of the table at beginning of file edge case.
    call search('|')
    norm! j
    " Remove everything that is not a pipe, colon or hyphen next to a colon othewise
    " well formated tables would grow because of addition of 2 spaces on the separator
    " line by Tabularize /|.
    let l:flags = (&gdefault ? '' : 'g')
    exe 's/\(:\@<!-:\@!\|[^|:-]\)//e' . l:flags
    exe 's/--/-/e' . l:flags
    Tabularize /|
    " Move colons for alignment to left or right side of the cell.
    exe 's/:\( \+\)|/\1:|/e' . l:flags
    exe 's/|\( \+\):/|:\1/e' . l:flags
    exe 's/|:\?\zs[ -]\+\ze:\?|/\=repeat("-", len(submatch(0)))/' . l:flags
    call setpos('.', l:pos)
endf
com!     -buffer TableFormat call s:TableFormat()


" Wrapper to do move commands in visual mode.
"
fun! s:VisMove(f)
    norm! gv
    call function(a:f)()
endf

" Map in both normal and visual modes.
"
fun! s:MapNormVis(rhs,lhs)
    exe 'nn <buffer><silent> ' . a:rhs . ' :call ' . a:lhs . '()<cr>'
    exe 'vn <buffer><silent> ' . a:rhs . ' <esc>:call <sid>VisMove(''' . a:lhs . ''')<cr>'
endf

" Parameters:
"
" - step +1 for right, -1 for left
"
" TODO: multiple lines.
"
fun! s:FindCornerOfSyntax(lnum, col, step)
    let l:col = a:col
    let l:syn = synIDattr(synID(a:lnum, l:col, 1), 'name')
    while synIDattr(synID(a:lnum, l:col, 1), 'name') ==# l:syn
        let l:col += a:step
    endwhile
    return l:col - a:step
endf

" Return the next position of the given syntax name,
" inclusive on the given position.
"
" TODO: multiple lines
"
fun! s:FindNextSyntax(lnum, col, name)
    let l:col = a:col
    let l:step = 1
    while synIDattr(synID(a:lnum, l:col, 1), 'name') !=# a:name
        let l:col += l:step
    endwhile
    return [a:lnum, l:col]
endf

fun! s:FindCornersOfSyntax(lnum, col)
    return [<sid>FindLeftOfSyntax(a:lnum, a:col), <sid>FindRightOfSyntax(a:lnum, a:col)]
endf

fun! s:FindRightOfSyntax(lnum, col)
    return <sid>FindCornerOfSyntax(a:lnum, a:col, 1)
endf

fun! s:FindLeftOfSyntax(lnum, col)
    return <sid>FindCornerOfSyntax(a:lnum, a:col, -1)
endf

" Returns:
"
" - a string with the the URL for the link under the cursor
" - an empty string if the cursor is not on a link
"
" TODO
"
" - multiline support
" - give an error if the separator does is not on a link
"
fun! s:Get_url(lnum, col)
    let l:lnum = a:lnum
    let l:col = a:col
    let l:syn = synIDattr(synID(l:lnum, l:col, 1), 'name')

    if l:syn ==# 'markdownInlineURL' || l:syn ==# 'markdownURL' || l:syn ==# 'markdownLinkDefTarget'
        " Do nothing.
    elseif l:syn ==# 'markdownLink'
        let [l:lnum, l:col] = <sid>FindNextSyntax(l:lnum, l:col, 'markdownURL')
        let l:syn = 'markdownURL'
    elseif l:syn ==# 'markdownDelimiter'
        let l:line = getline(l:lnum)
        let l:char = l:line[col - 1]
        if l:char ==# '<'
            let l:col += 1
        elseif l:char ==# '>' || l:char ==# ')'
            let l:col -= 1
        elseif l:char ==# '[' || l:char ==# ']' || l:char ==# '('
            let [l:lnum, l:col] = <sid>FindNextSyntax(l:lnum, l:col, 'markdownURL')
        el
            return ''
        en
    el
        return ''
    en

    let [l:left, l:right] = <sid>FindCornersOfSyntax(l:lnum, l:col)
    return getline(l:lnum)[l:left - 1 : l:right - 1]
endf

" Front end for GetUrlForPosition.
"
fun! s:OpenUrlUnderCursor()
    let l:url = s:Get_url(line('.'), col('.'))
    if l:url !=# ''
        call s:VersionAwareNetrwBrowseX(l:url)
    el
        echomsg 'The cursor is not on a link.'
    en
endf


" lwf改过
    " We need a definition guard because we invoke 'edit'
        " which will reload this  script while this function is running.
    if !exists('*s:jump')
        function s:jump()
            let how_edit = '-tab drop'
            let l:url    = s:Get_url(line('.') ,col('.'))
            if l:url !=# ''
                if get(g:, 'vim_markdown_autowrite', 0)
                    write
                en
                let l:anchor = ''
                if get(g:, 'vim_markdown_follow_anchor', 0)
                    let l:parts = split(l:url, '#', 1)
                    if len(l:parts) == 2
                        let [l:url, l:anchor] = parts
                        let l:anchorexpr = get(g:, 'vim_markdown_anchorexpr', '')
                        if l:anchorexpr !=# ''
                            let l:anchor = eval(substitute(
                                \ l:anchorexpr, 'v:anchor',
                                \ escape('"'.l:anchor.'"', '"'), ''))
                        en
                    en
                en
                if l:url !=# ''
                    let l:ext = ''
                    if get(g:, 'vim_markdown_no_extensions_in_markdown', 0)
                        " use another file extension if preferred
                        if exists('g:vim_markdown_auto_extension_ext')
                            let l:ext = '.'.g:vim_markdown_auto_extension_ext
                        el
                            let l:ext = '.md'
                        en
                    en
                    let l:url = fnameescape(fnamemodify(expand('%:h').'/'.l:url.l:ext, ':.'))
                    exe how_edit l:url
                en
                if l:anchor !=# ''
                    sil! exe '/'.l:anchor
                en
            el
                exe l:how_edit . ' <cfile>'
            en
        endf
    en
    nmap ge 0/(<CR>l<Cmd>call <sid>jump()<cr>
            "\ 跳到括号后


fun! s:VersionAwareNetrwBrowseX(url)
    call netrw#BrowseX(a:url, 0)
endf

fun! s:MapNotHasmapto(lhs, rhs)
    if !hasmapto('<Plug>' . a:rhs)
        exe 'nmap <buffer>' . a:lhs . ' <Plug>' . a:rhs
        exe 'vmap <buffer>' . a:lhs . ' <Plug>' . a:rhs
    en
endf

call <sid>MapNormVis('<Plug>Markdown_MoveToNextHeader'            , '<sid>MoveToNextHeader')
call <sid>MapNormVis('<Plug>Markdown_MoveToPreviousHeader'        , '<sid>MoveToPreviousHeader')
call <sid>MapNormVis('<Plug>Markdown_MoveToNextSiblingHeader'     , '<sid>MoveToNextSiblingHeader')
call <sid>MapNormVis('<Plug>Markdown_MoveToPreviousSiblingHeader' , '<sid>MoveToPreviousSiblingHeader')
call <sid>MapNormVis('<Plug>Markdown_MoveToParentHeader'          , '<sid>MoveToParentHeader')
call <sid>MapNormVis('<Plug>Markdown_MoveToCurHeader'             , '<sid>MoveToCurHeader')

nno      <Plug>Markdown_OpenUrlUnderCursor :call <sid>OpenUrlUnderCursor()<cr>
"\ nno      <Plug>Markdown_EditUrlUnderCursor :call <sid>EditUrlUnderCursor()<cr>

if !get(g:, 'vim_markdown_no_default_key_mappings', 0)
    call <sid>MapNotHasmapto(']]', 'Markdown_MoveToNextHeader')
    call <sid>MapNotHasmapto('[[', 'Markdown_MoveToPreviousHeader')
    call <sid>MapNotHasmapto('][', 'Markdown_MoveToNextSiblingHeader')
    call <sid>MapNotHasmapto('[]', 'Markdown_MoveToPreviousSiblingHeader')
    call <sid>MapNotHasmapto(']u', 'Markdown_MoveToParentHeader')
    call <sid>MapNotHasmapto(']h', 'Markdown_MoveToCurHeader')
    call <sid>MapNotHasmapto('gx', 'Markdown_OpenUrlUnderCursor')
    "\ call <sid>MapNotHasmapto('ge', 'Markdown_EditUrlUnderCursor')
en

com!     -buffer -range=% HeaderDecrease call s:HeaderDecrease(<line1>, <line2>)
com!     -buffer -range=% HeaderIncrease call s:HeaderDecrease(<line1>, <line2>, 1)
com!     -buffer -range=% SetexToAtx call s:SetexToAtx(<line1>, <line2>)
com!     -buffer Toc call s:Toc()
com!     -buffer -nargs=? InsertToc call s:InsertToc('bullets', <args>)
com!     -buffer -nargs=? InsertNToc call s:InsertToc('numbers', <args>)

" Heavily based on vim-notes - http://peterodding.com/code/vim/notes/
if exists('g:vim_markdown_fenced_languages')
    let s:filetype_dict = {}
    for s:filetype in g:vim_markdown_fenced_languages
        let key = matchstr(s:filetype, '[^=]*')
        let val = matchstr(s:filetype, '[^=]*$')
        let s:filetype_dict[key] = val
    endfor
el
    let s:filetype_dict = {
        \ 'c++': 'cpp',
        \ 'viml': 'vim',
        \ 'bash': 'sh',
        \ 'ini': 'dosini'
    \ }
en

fun! s:MarkdownHighlightSources(force)
    " Syntax highlight source code ¿embedded¿ in notes.
    " Look for code blocks in the current file
    let filetypes = {}
    for line in getline(1, '$')
        let ft = matchstr(line, '```\s*\zs[0-9A-Za-z_+-]*\ze.*')
        if !empty(ft) && ft !~# '^\d*$' | let filetypes[ft] = 1 | endif
    endfor
    if !exists('b:mkd_known_filetypes')
        let b:mkd_known_filetypes = {}
    en
    if !exists('b:mkd_included_filetypes')
        " set syntax file name included
        let b:mkd_included_filetypes = {}
    en
    if !a:force && (b:mkd_known_filetypes == filetypes || empty(filetypes))
        return
    en

    " Now we're ready to actually highlight the code blocks.
    let startgroup = 'markdownCodeStart'
    let endgroup = 'markdownCodeEnd'
    for ft in keys(filetypes)
        if a:force || !has_key(b:mkd_known_filetypes, ft)
            if has_key(s:filetype_dict, ft)
                let filetype = s:filetype_dict[ft]
            el
                let filetype = ft
            en
            let group = 'markdownSnippet' . toupper(substitute(filetype, '[+-]', '_', 'g'))
            if !has_key(b:mkd_included_filetypes, filetype)
                let include = s:SyntaxInclude(filetype)
                let b:mkd_included_filetypes[filetype] = 1
            el
                let include = '@' . toupper(filetype)
            en
            let command = 'syntax region %s matchgroup=%s start="^\s*```\s*%s.*$" matchgroup=%s end="\s*```$" keepend contains=%s%s'

            exe printf(
              \command,
              \group,
              \startgroup,
              \ft,
              \endgroup,
              \include,
              \has('conceal') && get(g:, 'vim_markdown_conceal', 1) && get(g:, 'vim_markdown_conceal_code_blocks', 1) ?
                  \ ' concealends'
                  \ : '',
              \)

            exe printf('syntax cluster markdownNonListItem add=%s', group)

            let b:mkd_known_filetypes[ft] = 1
        en
    endfor
endf

fun! s:SyntaxInclude(filetype)
    " Include the syntax highlighting of another {filetype}.
    let grouplistname = '@' . toupper(a:filetype)
    " Unset the name of the current syntax while including the other syntax
    " because some syntax scripts do nothing when "b:current_syntax" is set
    if exists('b:current_syntax')
        let syntax_save = b:current_syntax
        unlet b:current_syntax
    en
    try
        exe 'syntax include' grouplistname 'syntax/' . a:filetype . '.vim'
        exe 'syntax include' grouplistname 'after/syntax/' . a:filetype . '.vim'
    catch /E484/
        " Ignore missing scripts
    endt
    " Restore the name of the current syntax
    if exists('syntax_save')
        let b:current_syntax = syntax_save
    elseif exists('b:current_syntax')
        unlet b:current_syntax
    en
    return grouplistname
endf


fun! s:MarkdownRefreshSyntax(force)
    if &filetype =~# 'markdown'    &&    line('$') > 1
        call s:MarkdownHighlightSources(a:force)
    "     " " echo '我禁用了RefreshSyntax'
    endif
endf

fun! s:MarkdownClearSyntaxVariables()
    if &filetype =~# 'markdown'
        unlet! b:mkd_included_filetypes
    en
endf

aug  Mkd
    " These autocmd calling s:MarkdownRefreshSyntax need to be kept in sync with
        " the autocmds calling s:MarkdownSetupFolding in after/ftplugin/markdown.vim.
    au! * <buffer>
    au BufWinEnter                     <buffer> call s:MarkdownRefreshSyntax(1)
    au BufUnload                       <buffer> call s:MarkdownClearSyntaxVariables()
    au BufWritePost                    <buffer> call s:MarkdownRefreshSyntax(0)
    au InsertEnter,InsertLeave         <buffer> call s:MarkdownRefreshSyntax(0)
    au CursorHold,CursorHoldI  <buffer> call s:MarkdownRefreshSyntax(0)
aug  END

